/**
 * 验证工具类
 * 提供通用的数据验证功能
 */

/**
 * 验证对象是否为空
 * @param {Object} obj - 要验证的对象
 * @returns {boolean} 如果对象为空，则返回 true
 */
function isEmptyObject(obj) {
  if (!obj || typeof obj !== 'object') {
    return true;
  }
  return Object.keys(obj).length === 0;
}

/**
 * 验证字符串是否为空
 * @param {string} str - 要验证的字符串
 * @returns {boolean} 如果字符串为空或者只包含空格，则返回 true
 */
function isEmptyString(str) {
  return !str || typeof str !== 'string' || str.trim() === '';
}

/**
 * 验证数组是否为空
 * @param {Array} arr - 要验证的数组
 * @returns {boolean} 如果数组为空，则返回 true
 */
function isEmptyArray(arr) {
  return !arr || !Array.isArray(arr) || arr.length === 0;
}

/**
 * 验证值是否为数字
 * @param {*} value - 要验证的值
 * @returns {boolean} 如果值是数字，则返回 true
 */
function isNumber(value) {
  return typeof value === 'number' && !isNaN(value);
}

/**
 * 验证值是否在指定范围内
 * @param {number} value - 要验证的值
 * @param {number} min - 最小值
 * @param {number} max - 最大值
 * @returns {boolean} 如果值在指定范围内，则返回 true
 */
function isInRange(value, min, max) {
  if (!isNumber(value)) {
    return false;
  }
  return value >= min && value <= max;
}

/**
 * 验证是否为有效的时间格式（HH:mm）
 * @param {string} timeString - 要验证的时间字符串
 * @returns {boolean} 如果是有效的时间格式，则返回 true
 */
function isValidTimeFormat(timeString) {
  if (isEmptyString(timeString)) {
    return false;
  }
  
  const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
  return timePattern.test(timeString);
}

/**
 * 验证是否为有效的RGB值
 * @param {number} value - 要验证的RGB值
 * @returns {boolean} 如果是有效的RGB值，则返回 true
 */
function isValidRgb(value) {
  return isNumber(value) && isInRange(value, 0, 255);
}

/**
 * 验证是否为有效的RGB对象
 * @param {Object} rgb - 要验证的RGB对象，包含r、g、b三个属性
 * @returns {boolean} 如果是有效的RGB对象，则返回 true
 */
function isValidRgbObject(rgb) {
  if (!rgb || typeof rgb !== 'object') {
    return false;
  }
  return isValidRgb(rgb.r) && isValidRgb(rgb.g) && isValidRgb(rgb.b);
}

/**
 * 验证是否为有效的百分比值
 * @param {number} value - 要验证的百分比值
 * @returns {boolean} 如果是有效的百分比值，则返回 true
 */
function isValidPercentage(value) {
  return isNumber(value) && isInRange(value, 0, 100);
}

/**
 * 验证是否为有效的ID
 * @param {string} id - 要验证的ID
 * @returns {boolean} 如果是有效的ID，则返回 true
 */
function isValidId(id) {
  return !isEmptyString(id);
}

/**
 * 验证数据是否符合指定的模式
 * @param {Object} data - 要验证的数据对象
 * @param {Object} schema - 模式定义，键为属性名，值为验证函数
 * @returns {Object} 验证结果，包含isValid和errors属性
 */
function validateSchema(data, schema) {
  if (!data || typeof data !== 'object' || !schema || typeof schema !== 'object') {
    return { isValid: false, errors: ['数据或模式无效'] };
  }
  
  const errors = [];
  
  Object.keys(schema).forEach(key => {
    const validator = schema[key];
    if (typeof validator === 'function') {
      const result = validator(data[key]);
      if (result === false || (typeof result === 'object' && !result.isValid)) {
        errors.push({
          field: key,
          message: typeof result === 'object' ? result.message : `字段 ${key} 验证失败`
        });
      }
    }
  });
  
  return {
    isValid: errors.length === 0,
    errors
  };
}

module.exports = {
  isEmptyObject,
  isEmptyString,
  isEmptyArray,
  isNumber,
  isInRange,
  isValidTimeFormat,
  isValidRgb,
  isValidRgbObject,
  isValidPercentage,
  isValidId,
  validateSchema
}; 